{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1. 定义算法"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1.1. 定义模型\n",
    "\n",
    "注意DDGP中critic网络的输入是state加上action。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "class Actor(nn.Module):\n",
    "    def __init__(self, n_states, n_actions, hidden_dim = 256, init_w=3e-3):\n",
    "        super(Actor, self).__init__()  \n",
    "        self.linear1 = nn.Linear(n_states, hidden_dim)\n",
    "        self.linear2 = nn.Linear(hidden_dim, hidden_dim)\n",
    "        self.linear3 = nn.Linear(hidden_dim, n_actions)\n",
    "        \n",
    "        self.linear3.weight.data.uniform_(-init_w, init_w)\n",
    "        self.linear3.bias.data.uniform_(-init_w, init_w)\n",
    "        \n",
    "    def forward(self, x):\n",
    "        x = F.relu(self.linear1(x))\n",
    "        x = F.relu(self.linear2(x))\n",
    "        x = torch.tanh(self.linear3(x))\n",
    "        return x\n",
    "        \n",
    "class Critic(nn.Module):\n",
    "    def __init__(self, n_states, n_actions, hidden_dim=256, init_w=3e-3):\n",
    "        super(Critic, self).__init__()\n",
    "        \n",
    "        self.linear1 = nn.Linear(n_states + n_actions, hidden_dim)\n",
    "        self.linear2 = nn.Linear(hidden_dim, hidden_dim)\n",
    "        self.linear3 = nn.Linear(hidden_dim, 1)\n",
    "        # 随机初始化为较小的值\n",
    "        self.linear3.weight.data.uniform_(-init_w, init_w)\n",
    "        self.linear3.bias.data.uniform_(-init_w, init_w)\n",
    "        \n",
    "    def forward(self, state, action):\n",
    "        # 按维数1拼接\n",
    "        x = torch.cat([state, action], 1)\n",
    "        x = F.relu(self.linear1(x))\n",
    "        x = F.relu(self.linear2(x))\n",
    "        x = self.linear3(x)\n",
    "        return x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1.2 定义经验回放"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "from collections import deque\n",
    "import random\n",
    "class ReplayBuffer:\n",
    "    def __init__(self, capacity: int) -> None:\n",
    "        self.capacity = capacity\n",
    "        self.buffer = deque(maxlen=self.capacity)\n",
    "    def push(self,transitions):\n",
    "        '''_summary_\n",
    "        Args:\n",
    "            trainsitions (tuple): _description_\n",
    "        '''\n",
    "        self.buffer.append(transitions)\n",
    "    def sample(self, batch_size: int, sequential: bool = False):\n",
    "        if batch_size > len(self.buffer):\n",
    "            batch_size = len(self.buffer)\n",
    "        if sequential: # sequential sampling\n",
    "            rand = random.randint(0, len(self.buffer) - batch_size)\n",
    "            batch = [self.buffer[i] for i in range(rand, rand + batch_size)]\n",
    "            return zip(*batch)\n",
    "        else:\n",
    "            batch = random.sample(self.buffer, batch_size)\n",
    "            return zip(*batch)\n",
    "    def clear(self):\n",
    "        self.buffer.clear()\n",
    "    def __len__(self):\n",
    "        return len(self.buffer)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch.optim as optim\n",
    "import numpy as np\n",
    "class DDPG:\n",
    "    def __init__(self, models,memories,cfg):\n",
    "        self.device = torch.device(cfg['device'])\n",
    "        self.critic = models['critic'].to(self.device)\n",
    "        self.target_critic = models['critic'].to(self.device)\n",
    "        self.actor = models['actor'].to(self.device)\n",
    "        self.target_actor = models['actor'].to(self.device)\n",
    "        \n",
    "        # 复制参数到目标网络\n",
    "        for target_param, param in zip(self.target_critic.parameters(), self.critic.parameters()):\n",
    "            target_param.data.copy_(param.data)\n",
    "        for target_param, param in zip(self.target_actor.parameters(), self.actor.parameters()):\n",
    "            target_param.data.copy_(param.data)\n",
    "        self.critic_optimizer = optim.Adam(\n",
    "            self.critic.parameters(),  lr=cfg['critic_lr'])\n",
    "        self.actor_optimizer = optim.Adam(self.actor.parameters(), lr=cfg['actor_lr'])\n",
    "        self.memory = memories['memory']\n",
    "        self.batch_size = cfg['batch_size']\n",
    "        self.gamma = cfg['gamma']\n",
    "        self.tau = cfg['tau']  # 软更新参数\n",
    "    def sample_action(self, state):\n",
    "        state = torch.FloatTensor(state).unsqueeze(0).to(self.device)\n",
    "        action = self.actor(state)\n",
    "        return action.detach().cpu().numpy()[0, 0]\n",
    "    @torch.no_grad()\n",
    "    def predict_action(self, state):\n",
    "        ''' 用于预测，不需要计算梯度\n",
    "        '''\n",
    "        state = torch.FloatTensor(state).unsqueeze(0).to(self.device)\n",
    "        action = self.actor(state)\n",
    "        return action.cpu().numpy()[0, 0]\n",
    "    def update(self):\n",
    "        if len(self.memory) < self.batch_size: # 当memory中不满足一个批量时，不更新策略\n",
    "            return\n",
    "        # 从经验回放中中随机采样一个批量的transition\n",
    "        state, action, reward, next_state, done = self.memory.sample(self.batch_size)\n",
    "        # 转变为张量\n",
    "        state = torch.FloatTensor(np.array(state)).to(self.device)\n",
    "        next_state = torch.FloatTensor(np.array(next_state)).to(self.device)\n",
    "        action = torch.FloatTensor(np.array(action)).to(self.device)\n",
    "        reward = torch.FloatTensor(reward).unsqueeze(1).to(self.device)\n",
    "        done = torch.FloatTensor(np.float32(done)).unsqueeze(1).to(self.device)\n",
    "        # 注意看伪代码，这里的actor损失就是对应策略即actor输出的action下对应critic值的负均值\n",
    "        actor_loss = self.critic(state, self.actor(state))\n",
    "        actor_loss = - actor_loss.mean()\n",
    "\n",
    "        next_action = self.target_actor(next_state)\n",
    "        target_value = self.target_critic(next_state, next_action.detach())\n",
    "        # 这里的expected_value就是伪代码中间的y_i  \n",
    "        expected_value = reward + (1.0 - done) * self.gamma * target_value\n",
    "        expected_value = torch.clamp(expected_value, -np.inf, np.inf)\n",
    "\n",
    "        actual_value = self.critic(state, action)\n",
    "        critic_loss = nn.MSELoss()(actual_value, expected_value.detach())\n",
    "        \n",
    "        self.actor_optimizer.zero_grad()\n",
    "        actor_loss.backward()\n",
    "        self.actor_optimizer.step()\n",
    "        self.critic_optimizer.zero_grad()\n",
    "        critic_loss.backward()\n",
    "        self.critic_optimizer.step()\n",
    "        # 各自目标网络的参数软更新\n",
    "        for target_param, param in zip(self.target_critic.parameters(), self.critic.parameters()):\n",
    "            target_param.data.copy_(\n",
    "                target_param.data * (1.0 - self.tau) +\n",
    "                param.data * self.tau\n",
    "            )\n",
    "        for target_param, param in zip(self.target_actor.parameters(), self.actor.parameters()):\n",
    "            target_param.data.copy_(\n",
    "                target_param.data * (1.0 - self.tau) +\n",
    "                param.data * self.tau\n",
    "            )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2. 定义训练\n",
    "\n",
    "注意测试函数中不需要动作噪声"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "class OUNoise(object):\n",
    "    '''Ornstein–Uhlenbeck噪声\n",
    "    '''\n",
    "    def __init__(self, action_space, mu=0.0, theta=0.15, max_sigma=0.3, min_sigma=0.3, decay_period=100000):\n",
    "        self.mu           = mu # OU噪声的参数\n",
    "        self.theta        = theta # OU噪声的参数\n",
    "        self.sigma        = max_sigma # OU噪声的参数\n",
    "        self.max_sigma    = max_sigma\n",
    "        self.min_sigma    = min_sigma\n",
    "        self.decay_period = decay_period\n",
    "        self.n_actions   = action_space.shape[0]\n",
    "        self.low          = action_space.low\n",
    "        self.high         = action_space.high\n",
    "        self.reset()\n",
    "    def reset(self):\n",
    "        self.obs = np.ones(self.n_actions) * self.mu\n",
    "    def evolve_obs(self):\n",
    "        x  = self.obs\n",
    "        dx = self.theta * (self.mu - x) + self.sigma * np.random.randn(self.n_actions)\n",
    "        self.obs = x + dx\n",
    "        return self.obs\n",
    "    def get_action(self, action, t=0):\n",
    "        ou_obs = self.evolve_obs()\n",
    "        self.sigma = self.max_sigma - (self.max_sigma - self.min_sigma) * min(1.0, t / self.decay_period) # sigma会逐渐衰减\n",
    "        return np.clip(action + ou_obs, self.low, self.high) # 动作加上噪声后进行剪切\n",
    "\n",
    "def train(cfg, env, agent):\n",
    "    print(\"开始训练！\")\n",
    "    ou_noise = OUNoise(env.action_space)  # 动作噪声\n",
    "    rewards = [] # 记录所有回合的奖励\n",
    "    for i_ep in range(cfg['train_eps']):\n",
    "        state = env.reset()\n",
    "        ou_noise.reset()\n",
    "        ep_reward = 0\n",
    "        for i_step in range(cfg['max_steps']):\n",
    "            action = agent.sample_action(state)\n",
    "            action = ou_noise.get_action(action, i_step+1) \n",
    "            next_state, reward, done, _ = env.step(action)\n",
    "            ep_reward += reward\n",
    "            agent.memory.push((state, action, reward, next_state, done))\n",
    "            agent.update()\n",
    "            state = next_state\n",
    "            if done:\n",
    "                break\n",
    "        if (i_ep+1)%10 == 0:\n",
    "            print(f\"回合：{i_ep+1}/{cfg['train_eps']}，奖励：{ep_reward:.2f}\")\n",
    "        rewards.append(ep_reward)\n",
    "    print(\"完成训练！\")\n",
    "    return {'rewards':rewards}\n",
    "def test(cfg, env, agent):\n",
    "    print(\"开始测试！\")\n",
    "    rewards = [] # 记录所有回合的奖励\n",
    "    for i_ep in range(cfg['test_eps']):\n",
    "        state = env.reset() \n",
    "        ep_reward = 0\n",
    "        for i_step in range(cfg['max_steps']):\n",
    "            action = agent.predict_action(state)\n",
    "            next_state, reward, done, _ = env.step(action)\n",
    "            ep_reward += reward\n",
    "            state = next_state\n",
    "            if done:\n",
    "                break\n",
    "        rewards.append(ep_reward)\n",
    "        print(f\"回合：{i_ep+1}/{cfg['test_eps']}，奖励：{ep_reward:.2f}\")\n",
    "    print(\"完成测试！\")\n",
    "    return {'rewards':rewards}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3. 定义环境"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "import gym\n",
    "import os\n",
    "import torch\n",
    "import numpy as np\n",
    "import random\n",
    "class NormalizedActions(gym.ActionWrapper):\n",
    "    ''' 将action范围重定在[0.1]之间\n",
    "    '''\n",
    "    def action(self, action):\n",
    "        low_bound   = self.action_space.low\n",
    "        upper_bound = self.action_space.high\n",
    "        action = low_bound + (action + 1.0) * 0.5 * (upper_bound - low_bound)\n",
    "        action = np.clip(action, low_bound, upper_bound)\n",
    "        return action\n",
    "\n",
    "    def reverse_action(self, action):\n",
    "        low_bound   = self.action_space.low\n",
    "        upper_bound = self.action_space.high\n",
    "        action = 2 * (action - low_bound) / (upper_bound - low_bound) - 1\n",
    "        action = np.clip(action, low_bound, upper_bound)\n",
    "        return action\n",
    "def all_seed(env,seed = 1):\n",
    "    ''' 万能的seed函数\n",
    "    '''\n",
    "    env.seed(seed) # env config\n",
    "    np.random.seed(seed)\n",
    "    random.seed(seed)\n",
    "    torch.manual_seed(seed) # config for CPU\n",
    "    torch.cuda.manual_seed(seed) # config for GPU\n",
    "    os.environ['PYTHONHASHSEED'] = str(seed) # config for python scripts\n",
    "    # config for cudnn\n",
    "    torch.backends.cudnn.deterministic = True\n",
    "    torch.backends.cudnn.benchmark = False\n",
    "    torch.backends.cudnn.enabled = False\n",
    "def env_agent_config(cfg):\n",
    "    env = NormalizedActions(gym.make(cfg['env_name'])) # 装饰action噪声\n",
    "    if cfg['seed'] !=0:\n",
    "        all_seed(env,seed=cfg['seed'])\n",
    "    n_states = env.observation_space.shape[0]\n",
    "    n_actions = env.action_space.shape[0]\n",
    "    cfg.update({\"n_states\":n_states,\"n_actions\":n_actions}) # 更新n_states和n_actions到cfg参数中\n",
    "    models = {\"actor\":Actor(n_states,n_actions,hidden_dim=cfg['actor_hidden_dim']),\"critic\":Critic(n_states,n_actions,hidden_dim=cfg['critic_hidden_dim'])}\n",
    "    memories = {\"memory\":ReplayBuffer(cfg['memory_capacity'])}\n",
    "    agent = DDPG(models,memories,cfg)\n",
    "    return env,agent"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 4. 设置参数"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "import argparse\n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns\n",
    "def get_args():\n",
    "    \"\"\" 超参数\n",
    "    \"\"\"\n",
    "    parser = argparse.ArgumentParser(description=\"hyperparameters\")      \n",
    "    parser.add_argument('--algo_name',default='DDPG',type=str,help=\"name of algorithm\")\n",
    "    parser.add_argument('--env_name',default='Pendulum-v1',type=str,help=\"name of environment\")\n",
    "    parser.add_argument('--train_eps',default=300,type=int,help=\"episodes of training\")\n",
    "    parser.add_argument('--test_eps',default=20,type=int,help=\"episodes of testing\")\n",
    "    parser.add_argument('--max_steps',default=100000,type=int,help=\"steps per episode, much larger value can simulate infinite steps\")\n",
    "    parser.add_argument('--gamma',default=0.99,type=float,help=\"discounted factor\")\n",
    "    parser.add_argument('--critic_lr',default=1e-3,type=float,help=\"learning rate of critic\")\n",
    "    parser.add_argument('--actor_lr',default=1e-4,type=float,help=\"learning rate of actor\")\n",
    "    parser.add_argument('--memory_capacity',default=8000,type=int,help=\"memory capacity\")\n",
    "    parser.add_argument('--batch_size',default=128,type=int)\n",
    "    parser.add_argument('--target_update',default=2,type=int)\n",
    "    parser.add_argument('--tau',default=1e-2,type=float)\n",
    "    parser.add_argument('--critic_hidden_dim',default=256,type=int)\n",
    "    parser.add_argument('--actor_hidden_dim',default=256,type=int)\n",
    "    parser.add_argument('--device',default='cpu',type=str,help=\"cpu or cuda\")  \n",
    "    parser.add_argument('--seed',default=1,type=int,help=\"random seed\")\n",
    "    args = parser.parse_args([])    \n",
    "    args = {**vars(args)} # 将args转换为字典  \n",
    "    # 打印参数\n",
    "    print(\"训练参数如下：\")\n",
    "    print(''.join(['=']*80))\n",
    "    tplt = \"{:^20}\\t{:^20}\\t{:^20}\"\n",
    "    print(tplt.format(\"参数名\",\"参数值\",\"参数类型\"))\n",
    "    for k,v in args.items():\n",
    "        print(tplt.format(k,v,str(type(v))))   \n",
    "    print(''.join(['=']*80))                  \n",
    "    return args\n",
    "def smooth(data, weight=0.9):  \n",
    "    '''用于平滑曲线，类似于Tensorboard中的smooth\n",
    "\n",
    "    Args:\n",
    "        data (List):输入数据\n",
    "        weight (Float): 平滑权重，处于0-1之间，数值越高说明越平滑，一般取0.9\n",
    "\n",
    "    Returns:\n",
    "        smoothed (List): 平滑后的数据\n",
    "    '''\n",
    "    last = data[0]  # First value in the plot (first timestep)\n",
    "    smoothed = list()\n",
    "    for point in data:\n",
    "        smoothed_val = last * weight + (1 - weight) * point  # 计算平滑值\n",
    "        smoothed.append(smoothed_val)                    \n",
    "        last = smoothed_val                                \n",
    "    return smoothed\n",
    "\n",
    "def plot_rewards(rewards,cfg,path=None,tag='train'):\n",
    "    sns.set()\n",
    "    plt.figure()  # 创建一个图形实例，方便同时多画几个图\n",
    "    plt.title(f\"{tag}ing curve on {cfg['device']} of {cfg['algo_name']} for {cfg['env_name']}\")\n",
    "    plt.xlabel('epsiodes')\n",
    "    plt.plot(rewards, label='rewards')\n",
    "    plt.plot(smooth(rewards), label='smoothed')\n",
    "    plt.legend()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 5. 我准备好了！"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "训练参数如下：\n",
      "================================================================================\n",
      "        参数名         \t        参数值         \t        参数类型        \n",
      "     algo_name      \t        DDPG        \t   <class 'str'>    \n",
      "      env_name      \t    Pendulum-v1     \t   <class 'str'>    \n",
      "     train_eps      \t        300         \t   <class 'int'>    \n",
      "      test_eps      \t         20         \t   <class 'int'>    \n",
      "     max_steps      \t       100000       \t   <class 'int'>    \n",
      "       gamma        \t        0.99        \t  <class 'float'>   \n",
      "     critic_lr      \t       0.001        \t  <class 'float'>   \n",
      "      actor_lr      \t       0.0001       \t  <class 'float'>   \n",
      "  memory_capacity   \t        8000        \t   <class 'int'>    \n",
      "     batch_size     \t        128         \t   <class 'int'>    \n",
      "   target_update    \t         2          \t   <class 'int'>    \n",
      "        tau         \t        0.01        \t  <class 'float'>   \n",
      " critic_hidden_dim  \t        256         \t   <class 'int'>    \n",
      "  actor_hidden_dim  \t        256         \t   <class 'int'>    \n",
      "       device       \t        cpu         \t   <class 'str'>    \n",
      "        seed        \t         1          \t   <class 'int'>    \n",
      "================================================================================\n",
      "开始训练！\n",
      "回合：10/300，奖励：-1549.57\n",
      "回合：20/300，奖励：-1515.84\n",
      "回合：30/300，奖励：-1413.30\n",
      "回合：40/300，奖励：-972.99\n",
      "回合：50/300，奖励：-829.94\n",
      "回合：60/300，奖励：-727.91\n",
      "回合：70/300，奖励：-954.71\n",
      "回合：80/300，奖励：-1318.39\n",
      "回合：90/300，奖励：-981.19\n",
      "回合：100/300，奖励：-1262.05\n",
      "回合：110/300，奖励：-640.49\n",
      "回合：120/300，奖励：-1100.00\n",
      "回合：130/300，奖励：-764.66\n",
      "回合：140/300，奖励：-352.27\n",
      "回合：150/300，奖励：-891.03\n",
      "回合：160/300，奖励：-1318.07\n",
      "回合：170/300，奖励：-124.30\n",
      "回合：180/300，奖励：-240.08\n",
      "回合：190/300，奖励：-491.77\n",
      "回合：200/300，奖励：-1000.77\n",
      "回合：210/300，奖励：-128.87\n",
      "回合：220/300，奖励：-950.32\n",
      "回合：230/300，奖励：-122.48\n",
      "回合：240/300，奖励：-246.52\n",
      "回合：250/300，奖励：-374.37\n",
      "回合：260/300，奖励：-368.25\n",
      "回合：270/300，奖励：-364.17\n",
      "回合：280/300，奖励：-725.39\n",
      "回合：290/300，奖励：-131.21\n",
      "回合：300/300，奖励：-610.10\n",
      "完成训练！\n",
      "开始测试！\n",
      "回合：1/20，奖励：-116.05\n",
      "回合：2/20，奖励：-126.18\n",
      "回合：3/20，奖励：-231.46\n",
      "回合：4/20，奖励：-246.40\n",
      "回合：5/20，奖励：-304.69\n",
      "回合：6/20，奖励：-124.40\n",
      "回合：7/20，奖励：-1.06\n",
      "回合：8/20，奖励：-114.20\n",
      "回合：9/20，奖励：-348.97\n",
      "回合：10/20，奖励：-116.11\n",
      "回合：11/20，奖励：-117.20\n",
      "回合：12/20，奖励：-118.66\n",
      "回合：13/20，奖励：-235.18\n",
      "回合：14/20，奖励：-356.14\n",
      "回合：15/20，奖励：-118.39\n",
      "回合：16/20，奖励：-351.94\n",
      "回合：17/20，奖励：-114.51\n",
      "回合：18/20，奖励：-124.78\n",
      "回合：19/20，奖励：-226.47\n",
      "回合：20/20，奖励：-121.49\n",
      "完成测试！\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# 获取参数\n",
    "cfg = get_args() \n",
    "# 训练\n",
    "env, agent = env_agent_config(cfg)\n",
    "res_dic = train(cfg, env, agent)\n",
    " \n",
    "plot_rewards(res_dic['rewards'], cfg, tag=\"train\")  \n",
    "# 测试\n",
    "res_dic = test(cfg, env, agent)\n",
    "plot_rewards(res_dic['rewards'], cfg, tag=\"test\")  # 画出结果"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3.7.13 ('easyrl')",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.13"
  },
  "orig_nbformat": 4,
  "vscode": {
   "interpreter": {
    "hash": "8994a120d39b6e6a2ecc94b4007f5314b68aa69fc88a7f00edf21be39b41f49c"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
